import java.util.Scanner;

public class Day_ten {

    //过河卒（动态规划，路径问题）
    //棋盘上 A点有一个过河卒，需要走到目标 B点。卒行走的规则：可以向下、或者向右。
    // 同时在棋盘上 C 点有一个对方的马，该马所在的点和所有跳跃一步可达的点称为对方马的控制点。因此称之为“马拦过河卒”。
    //棋盘用坐标表示，A 点 (0, 0)、B点(n,m)，同样马的位置坐标是需要给出的。
    //现在要求你计算出卒从 A点能够到达 B点的路径的条数，假设马的位置(x,y)是固定不动的，并不是卒走一步马走一步。
    //注：马一次跳跃到达的点(x1,y1)和马原坐标(x,y)的关系是
    //∣x1−x∣+∣y1−y∣=3，且x1!=x, y1!=y
    //数据范围：1≤n,m≤20 ，马的坐标0≤x,y≤20
    //1≤a,b,c,d≤1000
    //输入描述：
    //仅一行，输入 n,m,x,y 四个正整数。分别表示B点坐标和马的坐标
    //输出描述：
    //输出路径总数
    //示例1
    //输入：
    //6 6 3 3
    //输出：
    //6
    //示例2
    //输入：
    //5 4 2 3
    //输出：
    //3
    //示例3
    //输入：
    //2 5 3 5
    //输出：
    //1
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);

        int n = s.nextInt();
        int m = s.nextInt();
        int x = s.nextInt();
        int y = s.nextInt();

        long[][] dp = new long[n+2][m+2];//创建dp表，多加一行和一列，方便进行初始化， dp[i][j]记录的是从原点到(i,j)有多少条路径
        dp[0][1] = 1;//初始化
        x += 1;
        y += 1;//将马的坐标跟随dp表一起移动一位

        for (int i = 1; i <= n+1; i++) {
            for (int j = 1; j <= m+1; j++) {
                if(i != x && j != y && Math.abs(i-x) +Math.abs(j-y) == 3 || (i == x && j == y)){
                    dp[i][j] = 0;
                }else{
                    dp[i][j] = dp[i-1][j] +dp[i][j-1];
                }
            }
        }
        System.out.println(dp[n+1][m+1]);
    }


    //买卖股票的最好时机（1）
    //假设你有一个数组prices，长度为n，其中prices[i]是股票在第i天的价格，
    // 请根据这个价格数组，返回买卖股票能获得的最大收益
    //1.你可以买入一次股票和卖出一次股票，并非每天都可以买入或卖出一次，
    // 总共只能买入和卖出一次，且买入必须在卖出的前面的某一天
    //2.如果不能获取到任何利润，请返回0
    //3.假设买入卖出均无手续费
    //数据范围：0≤n≤10^5,0≤val≤10^4
    //
    //输入描述：
    //第一行输入一个正整数 n 表示数组的长度
    //第二行输入 n 个正整数，表示股票在第 i 天的价格
    //输出描述：
    //输出只买卖一次的最高收益
    //示例1
    //输入：
    //7
    //8 9 2 5 4 7 1
    //输出：
    //5
    //说明：
    //在第3天(股票价格 = 2)的时候买入，在第6天(股票价格 = 7)的时候卖出，
    // 最大利润 = 7-2 = 5 ，不能选择在第2天买入，第3天卖出，这样就亏损7了；
    // 同时，你也不能在买入前卖出股票。
    //示例2
    //输入：
    //3
    //2 4 1
    //输出：
    //2
    //示例3
    //输入：
    //3
    //3 2 1
    //输出：
    //0
    public static void main1(String[] args) {
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int ret = 0;
        int prevMin = s.nextInt();
        int x = 0;
        for (int i = 0; i < n; i++) {
            x = s.nextInt();
            ret = Math.max(ret,x-prevMin);
            prevMin = Math.min(prevMin,x);
        }
        System.out.println(ret < 0 ? 0 : ret );
    }

    //最长回文子串
    //对于长度为n的一个字符串A（仅包含数字，大小写英文字母），
    // 请设计一个高效算法，计算其中最长回文子串的长度。
    //数据范围：1≤n≤1000
    //要求：空间复杂度O(1)，时间复杂度O(n^2)
    //进阶:  空间复杂度O(n)，时间复杂度O(n)
    //示例1
    //输入：
    //"ababc"
    //返回值：
    //3
    //说明：
    //最长的回文子串为"aba"与"bab"，长度都为3

    //示例2
    //输入：
    //"abbba"
    //返回值：
    //5

    //示例3
    //输入：
    //"b"
    //返回值：
    //1
    //思路：动态规划dp表，中心扩展算法
    public int getLongestPalindrome (String s){
        //中心扩展算法
        int n = s.length();
        int ret = 0;//记录回文长度

        for (int i = 0; i < n; i++) {
            //当回文子串是奇数个时
            int left = i-1;
            int right = i+1;
            while (left>=0 && right<n && s.charAt(left) == s.charAt(right)){
                left--;
                right++;
            }
            ret = Math.max(ret,right-left-1);

            //当回文子串是偶数个时，在跑一遍
            left = i;
            right = i+1;
            while (left>=0 && right<n && s.charAt(left) == s.charAt(right)){
                left--;
                right++;
            }
            ret = Math.max(ret,right-left-1);
        }
        return ret;

    }
}
